package WeekOne;

import java.util.*;

/**
 * @Author @fiber-cloud
 * @Date 2025/10/21 10:52
 */
public class DAY05 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int q = scanner.nextInt();
        int a,b,c;
        while (q-- != 0){
            a = scanner.nextInt();
            b = scanner.nextInt();
            c = scanner.nextInt();

            int x = Math.min(a, Math.min(b,c));

            System.out.println(x*2 + Math.max(b-x-1,0));
        }
    }


    public int rotApple (ArrayList<ArrayList<Integer>> grid) {
        //当出现2时，2的四周没有苹果时，有苹果永远不会腐烂
        // 将所有腐烂苹果作为BFS的起点同时加入队列
        // 每分钟处理当前队列中的所有苹果，模拟同时传播
        // 维护完好苹果的数量，实时更新
        
       
        if (grid == null || grid.size() == 0 || grid.get(0).size() == 0){
            return -1;
        }
        
        int n = grid.size();
        int m = grid.get(0).size();
        
        Queue<int[]> queue = new LinkedList<>();
        int freshApples = 0;//统计新鲜苹果的个数
        
        
        //初始化，将所有腐烂苹果位置加入队列，并统计完好苹果数量
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid.get(i).get(j) == 2){
                    queue.offer(new int[]{i,j});
                } else if (grid.get(i).get(j) == 1) {
                    freshApples++;
                }
            }
        }



        //查看是否有完好苹果，如果没有直接返回0
        if (freshApples == 0){
            return 0;
        }

        //方向数组
        int[][] dir = {{-1,0},{0,1},{1,0},{0,-1}};
        int minutes = 0;

        //开始BFS传播
        while (!queue.isEmpty() && freshApples >0){
            int size = queue.size();

            //处理当前时间内所有的腐烂苹果
            for (int i = 0; i < size; i++) {
                int[] current = queue.poll();
                int x = current[0],y = current[1];

                //向四个方向传播
                for (int[] dirs : dir){
                    int nx = x +dirs[0];
                    int ny = y +dirs[1];

                    //查看新位置是否有效且是完好苹果
                    if (nx >= 0 && nx < n && ny >= 0 && ny <m
                    && grid.get(nx).get(ny) == 1){
                        //腐蚀相邻苹果
                        grid.get(nx).set(ny,2);
                        freshApples--;
                        queue.offer(new int[]{nx,ny});
                    }
                }
            }
            minutes++;
        }
        return freshApples == 0?minutes:-1;

    }


    public int LastRemaining_Solution (int n, int m) {
        if (n <= 0 || m <= 0){
            return -1;
        }

        //创建一个小朋友。列表
        List<Integer> children = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            children.add(i);
        }

        //当前报数的小朋友
        int index = 0;

        while (children.size() > 1){
            //要出列的小朋友的位置：从当前索引开始数第m-1个
            index = (index + m -1) %children.size();

            //移除已经出列的小朋友
            children.remove(index);
            //移除后，下个小朋友会自动成为当前索引所指向的位置
        }
        return children.get(0);
    }

}
